﻿using Isuka;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections;
using System.Collections.Generic;

namespace isuka.tests
{
    
    
    /// <summary>
    ///GateTest のテスト クラスです。すべての
    ///GateTest 単体テストをここに含めます
    ///</summary>
    [TestClass()]
    public class GateTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///現在のテストの実行についての情報および機能を
        ///提供するテスト コンテキストを取得または設定します。
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region 追加のテスト属性
        // 
        //テストを作成するときに、次の追加属性を使用することができます:
        //
        //クラスの最初のテストを実行する前にコードを実行するには、ClassInitialize を使用
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //クラスのすべてのテストを実行した後にコードを実行するには、ClassCleanup を使用
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //各テストを実行する前にコードを実行するには、TestInitialize を使用
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //各テストを実行した後にコードを実行するには、TestCleanup を使用
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///InRange のテスト
        ///</summary>
        [TestMethod()]
        public void InRangeTest()
        {
            int index = 0; // TODO: 適切な値に初期化してください
            ICollection collection = null; // TODO: 適切な値に初期化してください
            Gate.InRange(index, collection);
            Assert.Inconclusive("値を返さないメソッドは確認できません。");
        }

        /// <summary>
        ///InRange のテスト
        ///</summary>
        public void InRangeTest1Helper<T>()
        {
            int index = 0; // TODO: 適切な値に初期化してください
            ICollection<T> collection = null; // TODO: 適切な値に初期化してください
            Gate.InRange<T>(index, collection);
            Assert.Inconclusive("値を返さないメソッドは確認できません。");
        }

        [TestMethod()]
        public void InRangeTest1()
        {
            InRangeTest1Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///InRange のテスト
        ///</summary>
        [TestMethod()]
        public void InRangeTest2()
        {
            int index = 0; // TODO: 適切な値に初期化してください
            int min = 0; // TODO: 適切な値に初期化してください
            int max = 0; // TODO: 適切な値に初期化してください
            Gate.InRange(index, min, max);
            Assert.Inconclusive("値を返さないメソッドは確認できません。");
        }

        /// <summary>
        ///NotEmpty のテスト
        ///</summary>
        [TestMethod()]
        public void NotEmptyTest()
        {
            ICollection collection = null; // TODO: 適切な値に初期化してください
            Gate.NotEmpty(collection);
            Assert.Inconclusive("値を返さないメソッドは確認できません。");
        }

        /// <summary>
        ///NotEmpty のテスト
        ///</summary>
        public void NotEmptyTest1Helper<T>()
        {
            ICollection<T> collection = null; // TODO: 適切な値に初期化してください
            Gate.NotEmpty<T>(collection);
            Assert.Inconclusive("値を返さないメソッドは確認できません。");
        }

        [TestMethod()]
        public void NotEmptyTest1()
        {
            NotEmptyTest1Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///NotNull のテスト
        ///</summary>
        public void NotNullTestHelper<T>()
        {
            T value = default(T); // TODO: 適切な値に初期化してください
            Func<Exception> exceptionFactory = null; // TODO: 適切な値に初期化してください
            T expected = default(T); // TODO: 適切な値に初期化してください
            T actual;
            actual = Gate.NotNull<T>(value, exceptionFactory);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("このテストメソッドの正確性を確認します。");
        }

        [TestMethod()]
        public void NotNullTest()
        {
            NotNullTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///NotNull のテスト
        ///</summary>
        public void NotNullTest1Helper<T>()
        {
            T value = default(T); // TODO: 適切な値に初期化してください
            T expected = default(T); // TODO: 適切な値に初期化してください
            T actual;
            actual = Gate.NotNull<T>(value);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("このテストメソッドの正確性を確認します。");
        }

        [TestMethod()]
        public void NotNullTest1()
        {
            NotNullTest1Helper<GenericParameterHelper>();
        }

        /// <summary>
        ///Positive のテスト
        ///</summary>
        [TestMethod()]
        public void PositiveTest()
        {
            int value = 0; // TODO: 適切な値に初期化してください
            Gate.Positive(value);
            Assert.Inconclusive("値を返さないメソッドは確認できません。");
        }

        /// <summary>
        ///RequireNotNull のテスト
        ///</summary>
        [TestMethod()]
        public void RequireNotNullTest()
        {
            object obj = null; // TODO: 適切な値に初期化してください
            string paramName = string.Empty; // TODO: 適切な値に初期化してください
            Gate.RequireNotNull(obj, paramName);
            Assert.Inconclusive("値を返さないメソッドは確認できません。");
        }

        /// <summary>
        ///Requires のテスト
        ///</summary>
        public void RequiresTestHelper<TException>()
            where TException : Exception
        {
            bool condition = false; // TODO: 適切な値に初期化してください
            string message = string.Empty; // TODO: 適切な値に初期化してください
            Gate.Requires<TException>(condition, message);
            Assert.Inconclusive("値を返さないメソッドは確認できません。");
        }

        [TestMethod()]
        public void RequiresTest()
        {
            Assert.Inconclusive("TException の型の制約を満たす適切な型パラメーターが見つかりません。適切な型パラメーターで RequiresTestHelper<TException>" +
                    "() を呼び出してください。");
        }

        /// <summary>
        ///Retry のテスト
        ///</summary>
        public void RetryTestHelper<T>()
        {
            Func<T> func = null; // TODO: 適切な値に初期化してください
            int retry = 0; // TODO: 適切な値に初期化してください
            T expected = default(T); // TODO: 適切な値に初期化してください
            T actual;
            actual = Gate.Retry<T>(func, retry);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("このテストメソッドの正確性を確認します。");
        }

        [TestMethod()]
        public void RetryTest()
        {
            RetryTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///RetryNotNull のテスト
        ///</summary>
        public void RetryNotNullTestHelper<T>()
            where T : class
        {
            Func<T> func = null; // TODO: 適切な値に初期化してください
            int retry = 0; // TODO: 適切な値に初期化してください
            T expected = null; // TODO: 適切な値に初期化してください
            T actual;
            actual = Gate.RetryNotNull<T>(func, retry);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("このテストメソッドの正確性を確認します。");
        }

        [TestMethod()]
        public void RetryNotNullTest()
        {
            RetryNotNullTestHelper<GenericParameterHelper>();
        }
    }
}
